//### This file created by BYACC 1.8(/Java extension  1.15)
//### Java capabilities added 7 Jan 97, Bob Jamison
//### Updated : 27 Nov 97  -- Bob Jamison, Joe Nieten
//###           01 Jan 98  -- Bob Jamison -- fixed generic semantic constructor
//###           01 Jun 99  -- Bob Jamison -- added Runnable support
//###           06 Aug 00  -- Bob Jamison -- made state variables class-global
//###           03 Jan 01  -- Bob Jamison -- improved flags, tracing
//###           16 May 01  -- Bob Jamison -- added custom stack sizing
//###           04 Mar 02  -- Yuval Oren  -- improved java performance, added options
//###           14 Mar 02  -- Tomas Hurka -- -d support, static initializer workaround
//### Please send bug reports to tom@hukatronic.cz
//### static char yysccsid[] = "@(#)yaccpar	1.8 (Berkeley) 01/20/90";



package cz.bsa.soft.i18nparser.core;



//#line 26 "textparser.y"
    import java.io.*;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Set;
    import java.util.HashSet;
//#line 23 "Parser.java"




public class Parser
{

boolean yydebug;        //do I want debug output?
int yynerrs;            //number of errors so far
int yyerrflag;          //was there an error?
int yychar;             //the current working character

//########## MESSAGES ##########
//###############################################################
// method: debug
//###############################################################
void debug(String msg)
{
  if (yydebug)
    System.out.println(msg);
}

//########## STATE STACK ##########
final static int YYSTACKSIZE = 500;  //maximum stack size
int statestk[] = new int[YYSTACKSIZE]; //state stack
int stateptr;
int stateptrmax;                     //highest index of stackptr
int statemax;                        //state when highest index reached
//###############################################################
// methods: state stack push,pop,drop,peek
//###############################################################
final void state_push(int state)
{
  try {
		stateptr++;
		statestk[stateptr]=state;
	 }
	 catch (ArrayIndexOutOfBoundsException e) {
     int oldsize = statestk.length;
     int newsize = oldsize * 2;
     int[] newstack = new int[newsize];
     System.arraycopy(statestk,0,newstack,0,oldsize);
     statestk = newstack;
     statestk[stateptr]=state;
  }
}
final int state_pop()
{
  return statestk[stateptr--];
}
final void state_drop(int cnt)
{
  stateptr -= cnt; 
}
final int state_peek(int relative)
{
  return statestk[stateptr-relative];
}
//###############################################################
// method: init_stacks : allocate and prepare stacks
//###############################################################
final boolean init_stacks()
{
  stateptr = -1;
  val_init();
  return true;
}
//###############################################################
// method: dump_stacks : show n levels of the stacks
//###############################################################
void dump_stacks(int count)
{
int i;
  System.out.println("=index==state====value=     s:"+stateptr+"  v:"+valptr);
  for (i=0;i<count;i++)
    System.out.println(" "+i+"    "+statestk[i]+"      "+valstk[i]);
  System.out.println("======================");
}


//########## SEMANTIC VALUES ##########
//## **user defined:I18nParserVal
String   yytext;//user variable to return contextual strings
I18nParserVal yyval; //used to return semantic vals from action routines
I18nParserVal yylval;//the 'lval' (result) I got from yylex()
I18nParserVal valstk[] = new I18nParserVal[YYSTACKSIZE];
int valptr;
//###############################################################
// methods: value stack push,pop,drop,peek.
//###############################################################
final void val_init()
{
  yyval=new I18nParserVal();
  yylval=new I18nParserVal();
  valptr=-1;
}
final void val_push(I18nParserVal val)
{
  try {
    valptr++;
    valstk[valptr]=val;
  }
  catch (ArrayIndexOutOfBoundsException e) {
    int oldsize = valstk.length;
    int newsize = oldsize*2;
    I18nParserVal[] newstack = new I18nParserVal[newsize];
    System.arraycopy(valstk,0,newstack,0,oldsize);
    valstk = newstack;
    valstk[valptr]=val;
  }
}
final I18nParserVal val_pop()
{
  return valstk[valptr--];
}
final void val_drop(int cnt)
{
  valptr -= cnt;
}
final I18nParserVal val_peek(int relative)
{
  return valstk[valptr-relative];
}
final I18nParserVal dup_yyval(I18nParserVal val)
{
  return val;
}
//#### end semantic value section ####
public final static short IDENTIFIER=257;
public final static short STRING=258;
public final static short BEGINTAG=259;
public final static short ENDTAG=260;
public final static short YYERRCODE=256;
final static short yylhs[] = {                           -1,
    0,    0,    0,    0,    0,    0,    0,    4,    4,    5,
    3,    1,    1,    1,    1,    1,    1,    1,    2,    2,
    2,    2,    2,
};
final static short yylen[] = {                            2,
    0,    1,    1,    1,    2,    2,    2,    1,    3,    4,
    4,    0,    1,    1,    3,    2,    3,    2,    3,    3,
    1,    5,    5,
};
final static short yydefred[] = {                         0,
    2,    0,    0,    0,    4,    3,    0,    0,    0,    6,
    7,    5,    0,    0,   13,   21,    0,    0,    0,    0,
    0,   11,    0,    0,   16,    9,   10,   19,    0,   20,
    0,    0,   15,   17,    0,    0,   22,   23,
};
final static short yydgoto[] = {                          4,
   14,   15,   16,    9,    6,
};
final static short yysindex[] = {                      -220,
    0,  -13, -222, -208,    0,    0, -217,  -17, -217,    0,
    0,    0,  -29,  -24,    0,    0, -215,  -32,  -87,  -81,
  -29,    0, -211, -207,    0,    0,    0,    0, -217,    0,
 -217,  -29,    0,    0,  -23,  -21,    0,    0,
};
final static short yyrindex[] = {                        52,
    0,    0,    0,    0,    0,    0,  -11,  -31,  -30,    0,
    0,    0,  -39,    0,    0,    0,    0,    0,    0,    0,
  -38,    0,    0,    0,    0,    0,    0,    0,  -20,    0,
  -20,    0,    0,    0,    0,    0,    0,    0,
};
final static short yygindex[] = {                         0,
   16,    8,   34,    0,   49,
};
final static int YYTABLESIZE=236;
static short yytable[];
static { yytable();}
static void yytable(){
yytable = new short[]{                         14,
   18,   14,   18,   29,   14,   18,   24,    8,   12,   31,
    7,   23,    8,   12,   24,   24,   22,   24,   12,   23,
   23,   25,   23,   12,   18,   25,    7,   12,   19,   12,
   33,   20,   12,    5,    8,    1,    2,   11,    3,   13,
   17,   26,   25,   25,   35,   32,   36,   10,    2,   34,
    3,    1,   12,   14,   18,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   37,
    0,   38,   12,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   28,    0,    0,    0,    0,    0,   30,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   14,   18,    0,
   14,   18,    0,    0,   21,    8,    0,   27,    8,   12,
    0,    0,   21,   21,    0,   21,
};
}
static short yycheck[];
static { yycheck(); }
static void yycheck() {
yycheck = new short[] {                         39,
   39,   41,   41,   91,   44,   44,   39,   39,   39,   91,
   40,   44,   44,   44,   39,   39,   41,   39,   39,   44,
   44,   14,   44,   44,    9,   18,   40,   39,   58,   41,
   23,   61,   44,    0,  257,  256,  257,    4,  259,  257,
   58,  257,   35,   36,   29,  257,   31,  256,  257,  257,
  259,    0,    4,   93,   93,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   93,
   -1,   93,   93,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  258,   -1,   -1,   -1,   -1,   -1,  258,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,  257,   -1,
  260,  260,   -1,   -1,  257,  257,   -1,  260,  260,  260,
   -1,   -1,  257,  257,   -1,  257,
};
}
final static short YYFINAL=4;
final static short YYMAXTOKEN=260;
final static String yyname[] = {
"end-of-file",null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,"'\\''","'('","')'",null,null,
"','",null,null,null,null,null,null,null,null,null,null,null,null,null,"':'",
null,null,"'='",null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,"'['",null,"']'",null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,
null,null,null,null,null,null,null,null,"IDENTIFIER","STRING","BEGINTAG",
"ENDTAG",
};
final static String yyrule[] = {
"$accept : File",
"File :",
"File : error",
"File : Tag",
"File : Function",
"File : File Tag",
"File : File error",
"File : File Function",
"TagIdentifier : IDENTIFIER",
"TagIdentifier : IDENTIFIER ':' IDENTIFIER",
"Tag : BEGINTAG TagIdentifier Parameters ENDTAG",
"Function : IDENTIFIER '(' Parameters ')'",
"Parameters :",
"Parameters : Parameter",
"Parameters : IDENTIFIER",
"Parameters : Parameters ',' Parameter",
"Parameters : Parameters Parameter",
"Parameters : Parameters '\\'' IDENTIFIER",
"Parameters : Parameters IDENTIFIER",
"Parameter : IDENTIFIER ':' STRING",
"Parameter : IDENTIFIER '=' STRING",
"Parameter : Function",
"Parameter : IDENTIFIER ':' '[' Parameters ']'",
"Parameter : IDENTIFIER '=' '[' Parameters ']'",
};

//#line 157 "textparser.y"
  private Yylex lexer;
  private Set<I18nProperty> i18nProperties = new HashSet<I18nProperty>();

  private int yylex () {
    int yyl_return = -1;
    try {
      yylval = new I18nParserVal(0);
      yyl_return = lexer.yylex();
    }
    catch (IOException e) {
      System.err.println("IO error :"+e);
    }
    return yyl_return;
  }


  public void yyerror (String error) {
    //ignoring errors, otherwise we had to recognize whole groovy, java, etc. grammars
    //System.err.println ("Bison Error: " + error);
  }


  public Parser(Reader r) {
    lexer = new Yylex(r, this);
  }

    public Set<I18nProperty> getI18nProperties(){
        yyparse();
        return i18nProperties;
    }
//#line 272 "Parser.java"
//###############################################################
// method: yylexdebug : check lexer state
//###############################################################
void yylexdebug(int state,int ch)
{
String s=null;
  if (ch < 0) ch=0;
  if (ch <= YYMAXTOKEN) //check index bounds
     s = yyname[ch];    //now get it
  if (s==null)
    s = "illegal-symbol";
  debug("state "+state+", reading "+ch+" ("+s+")");
}





//The following are now global, to aid in error reporting
int yyn;       //next next thing to do
int yym;       //
int yystate;   //current parsing state from state table
String yys;    //current token string


//###############################################################
// method: yyparse : parse input and execute indicated items
//###############################################################
int yyparse()
{
boolean doaction;
  init_stacks();
  yynerrs = 0;
  yyerrflag = 0;
  yychar = -1;          //impossible char forces a read
  yystate=0;            //initial state
  state_push(yystate);  //save it
  val_push(yylval);     //save empty value
  while (true) //until parsing is done, either correctly, or w/error
    {
    doaction=true;
    if (yydebug) debug("loop"); 
    //#### NEXT ACTION (from reduction table)
    for (yyn=yydefred[yystate];yyn==0;yyn=yydefred[yystate])
      {
      if (yydebug) debug("yyn:"+yyn+"  state:"+yystate+"  yychar:"+yychar);
      if (yychar < 0)      //we want a char?
        {
        yychar = yylex();  //get next token
        if (yydebug) debug(" next yychar:"+yychar);
        //#### ERROR CHECK ####
        if (yychar < 0)    //it it didn't work/error
          {
          yychar = 0;      //change it to default string (no -1!)
          if (yydebug)
            yylexdebug(yystate,yychar);
          }
        }//yychar<0
      yyn = yysindex[yystate];  //get amount to shift by (shift index)
      if ((yyn != 0) && (yyn += yychar) >= 0 &&
          yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
        {
        if (yydebug)
          debug("state "+yystate+", shifting to state "+yytable[yyn]);
        //#### NEXT STATE ####
        yystate = yytable[yyn];//we are in a new state
        state_push(yystate);   //save it
        val_push(yylval);      //push our lval as the input for next rule
        yychar = -1;           //since we have 'eaten' a token, say we need another
        if (yyerrflag > 0)     //have we recovered an error?
           --yyerrflag;        //give ourselves credit
        doaction=false;        //but don't process yet
        break;   //quit the yyn=0 loop
        }

    yyn = yyrindex[yystate];  //reduce
    if ((yyn !=0 ) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
      {   //we reduced!
      if (yydebug) debug("reduce");
      yyn = yytable[yyn];
      doaction=true; //get ready to execute
      break;         //drop down to actions
      }
    else //ERROR RECOVERY
      {
      if (yyerrflag==0)
        {
        yyerror("syntax error");
        yynerrs++;
        }
      if (yyerrflag < 3) //low error count?
        {
        yyerrflag = 3;
        while (true)   //do until break
          {
          if (stateptr<0)   //check for under & overflow here
            {
            yyerror("stack underflow. aborting...");  //note lower case 's'
            return 1;
            }
          yyn = yysindex[state_peek(0)];
          if ((yyn != 0) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
            if (yydebug)
              debug("state "+state_peek(0)+", error recovery shifting to state "+yytable[yyn]+" ");
            yystate = yytable[yyn];
            state_push(yystate);
            val_push(yylval);
            doaction=false;
            break;
            }
          else
            {
            if (yydebug)
              debug("error recovery discarding state "+state_peek(0)+" ");
            if (stateptr<0)   //check for under & overflow here
              {
              yyerror("Stack underflow. aborting...");  //capital 'S'
              return 1;
              }
            state_pop();
            val_pop();
            }
          }
        }
      else            //discard this token
        {
        if (yychar == 0)
          return 1; //yyabort
        if (yydebug)
          {
          yys = null;
          if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
          if (yys == null) yys = "illegal-symbol";
          debug("state "+yystate+", error recovery discards token "+yychar+" ("+yys+")");
          }
        yychar = -1;  //read another
        }
      }//end error recovery
    }//yyn=0 loop
    if (!doaction)   //any reason not to proceed?
      continue;      //skip action
    yym = yylen[yyn];          //get count of terminals on rhs
    if (yydebug)
      debug("state "+yystate+", reducing "+yym+" by rule "+yyn+" ("+yyrule[yyn]+")");
    if (yym>0)                 //if count of rhs not 'nil'
      yyval = val_peek(yym-1); //get current semantic value
    yyval = dup_yyval(yyval); //duplicate yyval if ParserVal is used as semantic value
    switch(yyn)
      {
//########## USER-SUPPLIED ACTIONS ##########
case 8:
//#line 58 "textparser.y"
{yyval.sval=val_peek(0).sval;}
break;
case 9:
//#line 59 "textparser.y"
{yyval.sval=val_peek(2).sval+":"+val_peek(0).sval;}
break;
case 10:
//#line 62 "textparser.y"
{
            /*System.out.println("Tag: " + $2.toString());*/
            /*System.out.println("   Params: " + $3);*/

            if(val_peek(2).sval.equals("g:submitButton")){
                int a = 1;
            }

            ParameterList params = val_peek(1).parameterlistval;
            if(val_peek(2).sval.equals("g:message")){
                I18nProperty property = params.getI18nProperty();
                if (property != null){
                    i18nProperties.add(property);
                }
            } else {
                i18nProperties.addAll(params.getI18nProperties());
            }
          }
break;
case 11:
//#line 82 "textparser.y"
{
            ParameterList params = val_peek(1).parameterlistval;
            String result = val_peek(3).sval.toString() + "(" + val_peek(1).parameterlistval + ")";
            /*System.out.println("Function: " + result);*/
            if(val_peek(3).sval.equals("message") || val_peek(3).sval.equals("g.message")){
                I18nProperty property = params.getI18nProperty();
                if (property != null){
                    i18nProperties.add(property);
                } 
                yyval.sval=result;
            } else {
                i18nProperties.addAll(params.getI18nProperties());
            }
        }
break;
case 12:
//#line 98 "textparser.y"
{yyval.parameterlistval=new ParameterList();}
break;
case 13:
//#line 99 "textparser.y"
{
                ParameterList params = new ParameterList();
                params.addAll(val_peek(0).parameterlistval);
                yyval.parameterlistval=params;
            }
break;
case 14:
//#line 104 "textparser.y"
{
                ParameterList params = new ParameterList();
                params.add(new Parameter(val_peek(0).sval,"",val_peek(0).sval));
                yyval.parameterlistval=params;
            }
break;
case 15:
//#line 109 "textparser.y"
{
                val_peek(2).parameterlistval.addAll(val_peek(0).parameterlistval);
                yyval.parameterlistval=val_peek(2).parameterlistval;
            }
break;
case 16:
//#line 113 "textparser.y"
{
                val_peek(1).parameterlistval.addAll(val_peek(0).parameterlistval);
                yyval.parameterlistval=val_peek(1).parameterlistval;
            }
break;
case 17:
//#line 117 "textparser.y"
{
                val_peek(2).parameterlistval.add(new Parameter(val_peek(0).sval,"",val_peek(0).sval));
                yyval.parameterlistval=val_peek(2).parameterlistval;
            }
break;
case 18:
//#line 121 "textparser.y"
{
                val_peek(1).parameterlistval.add(new Parameter(val_peek(0).sval,"",val_peek(0).sval));
                yyval.parameterlistval=val_peek(1).parameterlistval;
            }
break;
case 19:
//#line 128 "textparser.y"
{
                ParameterList params = new ParameterList();
                params.add(new Parameter(val_peek(2).sval, val_peek(0).sval, val_peek(2).sval+":"+val_peek(0).sval));
                yyval.parameterlistval=params;
            }
break;
case 20:
//#line 133 "textparser.y"
{
                ParameterList params = new ParameterList();
                params.add(new Parameter(val_peek(2).sval, val_peek(0).sval, val_peek(2).sval+"="+val_peek(0).sval));
                yyval.parameterlistval=params;
            }
break;
case 21:
//#line 138 "textparser.y"
{
                ParameterList params = new ParameterList();
                params.add(new Parameter("", val_peek(0).sval, val_peek(0).sval));
                yyval.parameterlistval=params;
            }
break;
case 22:
//#line 143 "textparser.y"
{
            ParameterList params = new ParameterList();
            params.add(new Parameter(val_peek(4).sval, val_peek(1).parameterlistval, val_peek(4).sval+":["+val_peek(1).parameterlistval+"]"));
            yyval.parameterlistval=params;
          }
break;
case 23:
//#line 148 "textparser.y"
{
            ParameterList params = new ParameterList();
            params.add(new Parameter(val_peek(4).sval, val_peek(1).parameterlistval, val_peek(4).sval+":["+val_peek(1).parameterlistval+"]"));
            yyval.parameterlistval=params;
          }
break;
//#line 555 "Parser.java"
//########## END OF USER-SUPPLIED ACTIONS ##########
    }//switch
    //#### Now let's reduce... ####
    if (yydebug) debug("reduce");
    state_drop(yym);             //we just reduced yylen states
    yystate = state_peek(0);     //get new state
    val_drop(yym);               //corresponding value drop
    yym = yylhs[yyn];            //select next TERMINAL(on lhs)
    if (yystate == 0 && yym == 0)//done? 'rest' state and at first TERMINAL
      {
      if (yydebug) debug("After reduction, shifting from state 0 to state "+YYFINAL+"");
      yystate = YYFINAL;         //explicitly say we're done
      state_push(YYFINAL);       //and save it
      val_push(yyval);           //also save the semantic value of parsing
      if (yychar < 0)            //we want another character?
        {
        yychar = yylex();        //get next character
        if (yychar<0) yychar=0;  //clean, if necessary
        if (yydebug)
          yylexdebug(yystate,yychar);
        }
      if (yychar == 0)          //Good exit (if lex returns 0 ;-)
         break;                 //quit the loop--all DONE
      }//if yystate
    else                        //else not done yet
      {                         //get next state and push, for next yydefred[]
      yyn = yygindex[yym];      //find out where to go
      if ((yyn != 0) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn]; //get new state
      else
        yystate = yydgoto[yym]; //else go to new defred
      if (yydebug) debug("after reduction, shifting from state "+state_peek(0)+" to state "+yystate+"");
      state_push(yystate);     //going again, so push state & val...
      val_push(yyval);         //for next action
      }
    }//main loop
  return 0;//yyaccept!!
}
//## end of method parse() ######################################



//## run() --- for Thread #######################################
/**
 * A default run method, used for operating this parser
 * object in the background.  It is intended for extending Thread
 * or implementing Runnable.  Turn off with -Jnorun .
 */
public void run()
{
  yyparse();
}
//## end of method run() ########################################



//## Constructors ###############################################
/**
 * Default constructor.  Turn off with -Jnoconstruct .

 */
public Parser()
{
  //nothing to do
}


/**
 * Create a parser, setting the debug to true or false.
 * @param debugMe true for debugging, false for no debug.
 */
public Parser(boolean debugMe)
{
  yydebug=debugMe;
}
//###############################################################



}
//################### END OF CLASS ##############################
